package org.shj.basic

import scala.collection.mutable.ListBuffer

/**
 * 一般而言， + 用于将元素添加到无先后次序的集合，而 +: 和 :+ 则是将元素添加到有
 * 先后次序的集合的开头或末尾
 */
object ListDemo {
  def main(args: Array[String]): Unit = {
    val lst = List(1,2,3,4,5)
    val that = List("a", "b")
    
    var result = lst ++ that // --> List(1, 2, 3, 4, 5, a, b)
    println("lst ++ that --> " + result)
    
    result = lst.+:("c")
    println("lst.+:(\"c\") --> " + result) // --> List(c, 1, 2, 3, 4, 5)
    
    println("\"c\" :+ lst --> " + ("c" :+ lst)) // Vector(c, List(1, 2, 3, 4, 5))
    
    val rst = lst :+ "a"
    println("lst :+ \"a\" --> " + rst) //List(1, 2, 3, 4, 5, a)
    
    result = lst.:::(List("d","f"))
    println("lst.:::(List(\"d\",\"f\")) --> " + result) // --> List(d, f, 1, 2, 3, 4, 5)
    
    //!!! 跟方法描述不一样。 ::: 操作符的结果和 .:::() 方法的结果不一样， 原因是：
    // ::: 是右操作符，  a ::: b 等同于  b.:::(a)
    // 注意：下面的 :: 也是右操作符
    result = lst ::: List("d","f") 
    println("lst ::: List(\"d\",\"f\") --> " + result) // --> List(1, 2, 3, 4, 5, d, f)
    
    result = lst.::("g")
    println("lst.::(\"g\") --> " + result) // --> List(g, 1, 2, 3, 4, 5)
    
    println("1 :: 2 :: 3 :: Nil --> " + (1 :: 2 :: 3 :: Nil)) // --> List(1, 2, 3)
    
    println("List.fill(3)(10) --> " + List.fill(3)(10)) //List(10, 10, 10)
    
    
    println("List.tabulate(4, 5)(_ * _) --> " + List.tabulate(4, 5)(_ * _))
    //以上输出 List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))
    
    println("List(1,2,3,4,5).reverse --> " + List(1,2,3,4,5).reverse) // List(5, 4, 3, 2, 1)
    
    val rst2 = lst./:(6)(_-_) // 等同于 foldLeft, 6为起始值，这个函数的作用是 6-1-2-3-4-5
    println("List(1,2,3,4,5)./:(6)(_-_) --> " + rst2) // -9
    
    println("========= test foreach() ============")
    val lstBuf = ListBuffer(1,2,3,4,5)
    lstBuf.foreach(item => item * 2)
    println(lstBuf) //可以得出foreach仅仅是循环每一条记录并进行相应的操作，但是并不改变列表中的值
    lstBuf.append(6)
    println(lstBuf)
    
    println("========= test map() ============")
    val mapped = lstBuf.map(item => item*2)
    println(lstBuf)
    println(mapped) //可以得出map仅仅是循环每一条记录并进行相应的操作，把结果放入到新的列表中，原来列表中的值不变
    
    println("========= test filter() ============")
    println(lstBuf.filter(_ > 3))
    println(lstBuf) //貌似对集合的操作，如果有返回值的话，都会生成新的列表，而不是改变原来列表中的值
    
    println("========= test drop() ============")
    println(lstBuf.drop(2)) //返回新列表
    println(lstBuf) //列表本身不变
    
    println("========= test zip() ============")
    println("List(1, 2, 3,4).zip(List(\"a\", \"b\", \"c\"))  -->  " + List(1, 2, 3,4).zip(List("a", "b", "c")))
    
    val it = Iterator(4,5,6,7)    
    println("it.max: " + it.max)
    //println("it.min: " + it.min)  //上面取得it.max的结果后，迭代器已经循环完了，已经无法再次使用。否则会报错
    
    val lst2 = List("Will","fill","Untill", "Spark")
    println(lst2.init) //返回除最后一项的list
    
    println("===== begin lst2.inits =====")
    var itList = lst2.inits //返回一个 iterator, 
    itList.foreach(println)
    println("===== end lst2.inits =====")
    
    println("===== begin mutable add =====")
    var results = collection.mutable.ListBuffer[String]()
    that.foreach(item => {
      results = results :+ item
    })
    println(results.length)
    println("===== end mutable add =====")
  }
}